home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Celestin Apprentice 4
/
Apprentice-Release4.iso
/
Languages
/
Yerk 3.6.7
/
yerk 367
/
nuc
/
yerk3.67.txt
< prev
Wrap
Text File
|
1994-09-21
|
80KB
|
1,717 lines
; System 7 modifications
; courier 9pt -9 spacing tabs: .875 1.5 3.625
; need to change modification in vers RSRC
; flush caches in trap; fix d0 saves for flushes
; fixed s,; added ucase in word_
; 6/1/94 changed at1,2,4 to not use (sp)+,-
; 3.66=3.64
; Load equates for Toolbox, Quickdraw
LIST OFF
INCLUDE "library.asm"
INCLUDE "equates.asm"
INCLUDE "yerk.macro"
*
gestalt EQU $a1ad
newhandc EQU $a322
newPtrc EQU $a31e
stripAddress EQU $a055
waitNextEvt EQU $a860
HWPriv EQU $a198
GLOBAL $200,$200
ENDG
TFILE "YERK.BIN"
RFILE "YERK",APPL,YERK,$2100 ; has bundle,init
;
Rsize EQU 400 ; Maximum depth of ret+mstack
Rbytes EQU -Rsize*4 ; Number of bytes for ret+mstack
MSbytes EQU 1200 ; 300 cells on methods stack
sysVects EQU 17 ; how many system vectors + 1 (for len)
sysVecSz EQU sysVects*4 ; total len of system vector table
; 'SAVE' HEADER EQUATES.
udp EQU 0 ; User dictionary pointer
ufence EQU 4 ; User fence pointer
uvocl EQU 8 ; User vocabulary pointer
ulatest EQU 12 ; Latest NFA.
headlen EQU 16 ; Lengt
mulu d0,d2
add.l d2,(SP)
move.l (a6)+,-(SP)
rts
smpy move.l (SP)+,-(a6)
tst.l (SP) ; signed multiply
smi d4
bpl smpy1
neg.l (SP)
smpy1 tst.l 4(SP)
smi d3
bpl smpy2
neg.l 4(SP)
smpy2 eor.b d3,d4
bsr.s mpy
tst.b d4
beq smpy3
neg.l 4(SP)
negx.l (SP)
smpy3 move.l (a6)+,-(SP)
rts
xdiv move.l (SP)+,-(a6)
tst.l (SP)
beq div5
tst.w (SP)
bne longdiv
tst.l 4(SP)
bne longdiv
move.l (SP)+,d2
popd0
popd1
divu d2,d1
bvs long1
clr.l d2
move.w d1,d2
clr.w d1
swap d1
pushd1
move.l d2,-(SP)
move.l (a6)+,-(SP)
rts
longdiv move.l (SP)+,d2 ; the dreaded long division
popd0
popd1
long1 moveq #32,d3
sub.l d2,d0
div1 bmi div2
ori.l #1,d1
subq.w #1,d3
bmi div3
asl.l #1,d1
roxl.l #1,d0
sub.l d2,d0
bra.s div1
div2 subq.w #1,d3
bmi div3
asl.l #1,d1
roxl.l #1,d0
add.l d2,d0
bra.s div1
div3 tst.l d0
bpl div4
add.l d2,d0
div4 pushd0
pushd1
move.l (a6)+,-(SP)
rts
div5 addq.l #4,SP
move.l d2,4(SP)
move.l #$7fffffff,(SP)
move.l (a6)+,-(SP)
rts
sdiv move.l (SP)+,-(a6) ; save return address from jsr
tst.l (SP) ; signed divide
smi d7 ; d4 change to d7 8-24-91
bpl sdiv1
neg.l (SP)
sdiv1 tst.l 4(SP)
smi d4 ; d7 changed to d4 to let rem sign = quotient sign
bpl sdiv2
neg.l 8(SP)
negx.l 4(SP)
sdiv2 eor.b d4,d7
bsr xdiv
tst.b d7
beq sdiv3
neg.l (SP)
sdiv3 tst.b d4
beq sdiv4
neg.l 4(SP)
sdiv4 move.l (a6)+,-(SP)
rts
slmod move.l (SP)+,-(a6)
moveq #0,d1
popd0
tst.l (SP)
bpl slmod1
subq.l #1,d1
slmod1 pushd1
pushd0
move.l (a6)+,-(SP)
bra.s sdiv
*
dcode U*,x,cmove,ustar
bsr mpy
gonext
*
dcode U/,x,ustar,uslash
bsr xdiv
gonext
*
dcode M*,x,uslash,mstar
bsr smpy
gonext
*
dcode M/,x,mstar,mslash
bsr sdiv
gonext
*
dcode */,x,mslash,starsla
move.l (SP)+,-(a6)
bsr smpy
move.l (a6)+,-(SP)
bsr sdiv
move.l (SP)+,(SP)
gonext
*
dcode */MOD,x,starsla,ssmod
move.l (SP)+,-(a6)
bsr smpy
move.l (a6)+,-(SP)
bsr sdiv
gonext
*
dcode M/MOD,x,ssmod,msmod
move.l (SP)+,-(a6)
moveq #0,d0
pushd0
move.l (a6),-(SP)
bsr xdiv
move.l (a6)+,d0
move.l (SP)+,-(a6)
pushd0
bsr xdiv
move.l (a6)+,-(SP)
gonext
*
dcode *,x,msmod,star ; *
bsr smpy
addq.l #4,SP ; drop top of stack
gonext
*
dcode /,x,star,slash ; /
bsr slmod
move.l (SP)+,(SP)
gonext
*
dcode /MOD,x,slash,xslmod ; /MOD
bsr slmod
gonext
*
dcode MOD,x,xslmod,mod ; MOD
bsr slmod
addq.l #4,SP
gonext
*
dcode D>,x,mod,dgrt ; D>
moveq #1,d0
move.l 8(SP),d1
cmp.l (SP),d1
bgt dgrt1
move.l 12(SP),d1
cmp.l 4(SP),d1
bgt dgrt1
moveq #0,d0
dgrt1 adda.l #16,SP
pushd0
gonext
*
dcode D<,x,dgrt,dless ; D<
moveq #1,d0
move.l 8(SP),d1
cmp.l (SP),d1
blt dless1
move.l 12(SP),d1
cmp.l 4(SP),d1
blt dless1
moveq #0,d0
dless1 adda.l #16,SP
pushd0
gonext
*
dcode D=,x,dless,dequ ; D=
move.l (SP),d1
cmp.l 8(SP),d1
seq d0
move.l 4(SP),d1
cmp.l 12(SP),d1
seq d1
adda.l #16,SP
and.l d1,d0
bra setbyt
gonext
*
dcode U<,x,dequ,uless
cmp2
scs d0
bra.s setbyt
*
dcode U>,x,uless,ugrt
cmp2
scc d0
bra.s setbyt
*
dcode <,x,ugrt,less ; <
cmp2
slt d0
bra.s setbyt
*
dcode >,x,less,grt ; >
cmp2
sgt d0
bra.s setbyt
*
dcode =,x,grt,equals ; =
cmp2
seq d0
bra.s setbyt
*
dcode <>,x,equals,nequals
cmp2
sne d0
bra.s setbyt
*
dcode 0=,x,nequals,zequ
tst.l (SP)+
seq d0
bra.s setbyt
*
dcode 0<,x,zequ,zless
tst.l (SP)+
smi d0
setbyt moveq #1,d1
and.l d1,d0
pushD0
gonext
*
dcode 0>,x,zless,zgrt
tst.l (SP)+
sgt d0
bra.s setbyt
*
dcode <=,x,zgrt,lesequ
cmp2
sle d0
bra.s setbyt
*
dcode >=,x,lesequ,grtequ
cmp2
sge d0
bra.s setbyt
*
dcode 0!,x,grtequ,zstore ; store 0 at addr
move.l (sp)+,d7
clr.l 0(a3,d7.l)
gonext
*
dcode 0,x,zstore,pzer ; short, fast 0 word
clr.l -(SP)
gonext
*
dcode 1,x,pzer,pone ; short, fast 1 word
move.l #1,-(SP)
gonext
*
dcode -1,x,pone,pmone ; short, fast -1 word
move.l #-1,-(SP)
gonext
*
dcode 2,x,pmone,ptwo ; short, fast 2 word
move.l #2,-(SP)
gonext
*
dcode 4,x,ptwo,pfour
move.l #4,-(SP)
gonext
*
dcode AND,x,pfour,and_
popD0
and.l d0,(SP)
gonext
*
dcode LAND,x,and_,land_
popd0
tst.l (SP)
beq land2
move.l #1,(SP)
tst.l d0
beq land1
mo
gonext
*
dcode MP2,x,mp1,mp2 ; mstack picks for named parms
move.l d5,a2
move.l 16(a2),-(SP) ; push parm to data stack
gonext
*
dcode MP3,x,mp2,mp3 ; mstack picks for named parms
move.l d5,a2
move.l 20(a2),-(SP) ; push parm to data stack
gonext
*
dcode MP4,x,mp3,mp4 ; mstack picks for named parms
move.l d5,a2
move.l 24(a2),-(SP) ; push parm to data stack
gonext
*
dcode MP5,x,mp4,mp5 ; mstack picks for named parms
move.l d5,a2
move.l 28(a2),-(SP) ; push parm to data stack
gonext
*
dcode MS0,x,mp5,ms0 ; mstack stores for named parms
move.l d5,a2
move.l (SP)+,8(a2) ; replace parm val with top of stack
gonext
*
dcode MS1,x,ms0,ms1 ; mstack stores for named parms
move.l d5,a2
move.l (SP)+,12(a2) ; replace parm val with top of stack
gonext
*
dcode MS2,x,ms1,ms2 ; mstack stores for named parms
move.l d5,a2
move.l (SP)+,16(a2) ; replace parm val with top of stack
gonext
*
dcode MS3,x,ms2,ms3 ; mstack stores for named parms
move.l d5,a2
move.l (SP)+,20(a2) ; replace parm val with top of stack
gonext
*
dcode MS4,x,ms3,ms4 ; mstack stores for named parms
move.l d5,a2
move.l (SP)+,24(a2) ; replace parm val with top of stack
gonext
*
dcode MS5,x,ms4,ms5 ; mstack stores for named parms
move.l d5,a2
move.l (SP)+,28(a2) ; replace parm val with top of stack
gonext
*
dcode (++>),x,ms5,minc ; increment named parm
move.l d5,a2
move.w (a4)+,d0 ; get element offset
move.l (sp)+,d1 ; get increment value
add.l d1,0(a2,d0.w) ; increment the cell
gonext
*
dcode (EX>),x,minc,mdo ; execute a procedural arg
move.l d5,a2
move.w (a4)+,d0 ; get offset to named parm
move.l 0(a2,d0.w),d6 ; get the cfa
move.l 0(a3,d6.l),d7 ; get the code
jmp 0(a3,d7.l)
*
dcode +,x,mdo,plus
popD0
add.l d0,(SP)
gonext
*
dcode -,x,plus,subt
popD0
sub.l d0,(SP)
gonext
*
dcode MAX,x,subt,max
popD0
cmp.l (SP),d0
blt maxq
move.l d0,(SP)
maxq gonext
*
dcode MIN,x,max,min
popD0
cmp.l (SP),d0
bgt minq
move.l d0,(SP)
minq gonext
*
dcode NEGATE,x,min,minus
mins1 neg.l (SP)
gonext
*
dcode DNEGATE,x,minus,dminus
dmins1 neg.l 4(SP)
negx.l (SP)
gonext
*
dcode CFA,x,dminus,cfa
subq.l #4,(SP)
gonext
*
dcode +-,x,cfa,plmin
tst.l (SP)+
bmi.s mins1
gonext
*
dcode ABS,x,plmin,abs
tst.l (SP)
bmi.s mins1
gonext
*
dcode DABS,x,abs,dabs
tst.l (SP)
bmi.s dmins1
gonext
*
dcode S->D,x,dabs,sToD
moveq #0,d0
tst.l (SP)
bpl GOHERE
subq.l #1,d0
GOHERE pushd0
gonext
*
dcode OVER,x,sToD,over
move.l 4(SP),-(SP)
gonext
*
dcode 2OVER,x,over,over2
move.l 12(SP),-(SP)
move.l 12(SP),-(SP)
gonext
*
dcode DROP,x,over2,drop
addq.l #4,SP
gonext
*
dcode 2DROP,x,drop,drop2
addq.l #8,SP
gonext
*
dcode SWAP,x,drop2,swap_
popD0
move.l (SP),d1
move.l d0,(SP)
pushD1
gonext
*
dcode 2SWAP,x,swap_,swap2
popD0
popD1
move.l (SP)+,d3
move.l (SP),d4
move.l d1,(SP)
move.l d0,-(SP)
move.l d4,-(SP)
move.l d3,-(SP)
gonext
*
dcode DUP,x,swap2,dup
move.l (SP),-(SP)
gonext
*
dcode 2DUP,x,dup,dup2
move.l 4(SP),-(SP)
move.l 4(SP),-(SP)
gonext
*
dcode -DUP,x,dup2,mindup
tst.l (SP)
beq ddup
move.l (SP),-(SP)
ddup gonext
*
dcode +!,x,mindup,plstor
move.l (SP)+,d7
popD0
add.l d0,0(a3,d7.l)
gonext
*
dcode TOGGLE,x,plstor,toggle
popD0
move.l (SP)+,d7
eor.b d0,0(a3,d7.l)
gonext
*
dcode W@,x,toggle,wfetch ; this is a 16-bit fetch
clr.l d0
move.l (SP),d7
move.w 0(a3,d7.l),d0
move.l d0,(SP)
gonext
*
dcode @,x,wfetch,fetch ; this is a 32-bit fetch
move.l (SP),d7
move.l 0(a3,d7.l),(SP)
gonext
*
dcode C@,x,fetch,cfetch
clr.l d0
move.l (SP),d7
move.b 0(a3,d7.l),d0
move.l d0,(SP)
gonext
*
dcode MW@,x,cfetch,mwfetch ; 16-bit fetch from mstack addr
move.l d5,a2
clr.l d0
move.l (a2),d7
move.w 0(a3,d7.l),d0
ext.l d0 ; sign-extend
move.l d0,-(SP)
gonext
*
dcode M@,x,mwfetch,mfetch ; this is a 32-bit fetch
move.l d5,a2
move.l (a2),d7
move.l 0(a3,d7.l),-(SP)
gonext
*
dcode 2@,x,mfetch,fetch2 ; ( double word fetch )
move.l (SP),d7
lea 0(a3,d7.l),a0
move.l (a0)+,-(sp)
move.l (a0),4(SP)
gonext
*
dcode W!,x,fetch2,wstore ; 16-bit store
move.l (SP)+,d7 ; address is relative to a3
popD0 ; d0 has value
move.w d0,0(a3,d7.l)
gonext
*
dcode W+!,x,wstore,wpstore ; 16-bit plus store
move.l (SP)+,d7
popD0
add.w d0,0(a3,d7.l)
gonext
*
dcode !,x,wpstore,store ; 32-bit store
move.l (SP)+,d7 ; address is relative to a3
popD0 ; d0 has value
move.l d0,0(a3,d7.l)
gonext
*
dcode C!,x,store,cstore
move.l (SP)+,d7
popD0
move.b d0,0(a3,d7.l)
gonext
*
dcode C+!,x,cstore,cpstore ; 8 bit plus store
move.l (SP)+,d7
popD0
add.b d0,0(a3,d7.l)
gonext
*
dcode MW!,x,cpstore,mwstore ; 16-bit store to addr on mstack
move.l d5,a2
move.l (a2),d7 ; address is relative to a3
popD0 ; d0 has value
move.w d0,0(a3,d7.l)
gonext
*
dcode M!,x,mwstore,mstore ; 32-bit store to addr on mstack
move.l d5,a2
move.l (a2),d7 ; address is relative to a3
popD0 ; d0 has value
move.l d0,0(a3,d7.l)
gonext
*
dcode 2!,x,mstore,store2 ; ( double word store )
move.l (SP)+,d7
lea 0(a3,d7.l),a0
move.l (SP)+,(a0)+
move.l (SP)+,(a0)
gonext
*
dcode D+,x,store2,dplus ; 64-bit add
popd0
popd1
move.l (SP)+,d2
move.l (sp)+,d3
add.l d1,d3
addx.l d0,d2
move.l d3,-(SP)
move.l d2,-(SP)
gonext
*
dcode 1+,x,dplus,plus1
addq.l #1,(SP)
gonext
*
dcode 2+,x,plus1,plus2
addq.l #2,(SP)
gonext
*
dcode 3+,x,plus2,plus3
addq.l #3,(SP)
gonext
*
dcode 4+,x,plus3,plus4
addq.l #4,(SP)
gonext
*
dcode 8+,x,plus4,plus8
addq.l #8,(SP)
gonext
*
dcode 1-,x,plus8,min1
subq.l #1,(SP)
gonext
*
dcode 2-,x,min1,min2
subq.l #2,(SP)
gonext
*
dcode 4-,x,min2,min4
subq.l #4,(SP)
gonext
*
dcode 8-,x,min4,min8
subq.l #8,(SP)
gonext
*
dcode 2*,x,min8,times2
move.l (SP),d0
asl.l #1,d0
move.l d0,(SP)
gonext
*
dcode 4*,x,times2,times4
move.l (SP),d0
asl.l #2,d0
move.l d0,(SP)
gonext
*
dcode 8*,x,times4,times8
move.l (SP),d0
asl.l #3,d0
move.l d0,(SP)
gonext
*
dcode 2/,x,times8,xdiv2
move.l (SP),d0
asr.l #1,d0
move.l d0,(SP)
gonext
*
; ^elem expects base addr on mstack, and an index on pstack
dcode (^ELEM),x,xdiv2,pelem ; return address of array eleme
move.l d5,a2 ; pickup base address on mstack
move.l (a2),d7 ; base of object in d7
move.l -4(a3,d7.l),d0 ; d0 has ^class of object
clr.l d1
move.w 18(a3,d0.l),d1 ; d1 has dlen of object
add.l d1,d7 ; d7 points to idx hdr
move.w 0(a3,d7.l),d1 ; fetch width word from header
mulu 2(SP),d1 ; multiply index * width
add.l d1,d7 ; add to base address
addq.l #4,d7 ; skip the header
move.l d7,(SP) ; leave on data stack
gonext
*
dcode IDXBASE,x,pelem,idxbas ; idx addr of indexed object
move.l d5,a2 ; pickup base address on mstack
move.l (a2),d7 ; base of object in d7
move.l -4(a3,d7.l),d0 ; d0 has ^class of object
clr.l d1
move.w 18(a3,d0.l),d1 ; d1 has dlen of object
add.l d1,d7 ; d7 points to idx hdr
addq.l #4,d7 ; skip the idx hdr
move.l d7,-(SP) ; leave the ^ixdata
gonext
*
dcode LIMIT,x,idxbas,limit ; limit of indexed object
move.l d5,a2 ; pickup base address on mstack
move.l (a2),d7 ; base of object in d7
move.l -4(a3,d7.l),d0 ; d0 has ^class of object
clr.l d1
move.w 18(a3,d0.l),d1 ; d1 has dlen of object
add.l d1,d7 ; d7 points to idx hdr
move.w 2(a3,d7.l),-(SP) ; leave the limit
clr.w -(SP)
gonext
*
dcode RANGE?,x,limit,qrange ; index out of range?
move.l d5,a2 ; pickup base address on mstack
move.l (a2),d7 ; base of object in d7
move.l -4(a3,d7.l),d0 ; d0 has ^class of object
clr.l d1
move.w 18(a3,d0.l),d1 ; d1 has dlen of object
add.l d1,d7 ; d7 points to idx hdr
clr.l d0
move.w 2(a3,d7.l),d0 ; get the limit
cmp.l (SP),d0 ; is limit > index?
sle d1 ; true if out of range
neg.b d1 ; forth boolean
move.l d1,-(SP)
gonext
*
; at1 treats value as unsigned
dcode AT1,x,qrange,at1 ; at opt for byte elements
move.l d5,a2 ; pickup base address on mstack
move.l (a2),d7 ; base of object in d7
move.l -4(a3,d7.l),d0 ; d0 has ^class of object
clr.l d1
move.w 18(a3,d0.l),d1 ; d1 has dlen of object
add.l d1,d7 ; d7 points to idx hdr
add.l (SP),d7 ; add the index
clr.l d0
move.b 4(a3,d7.l),d0 ; fetch addr+4 (for idx hdr)
move.l d0,(SP)
gonext
*
dcode AT2,x,at1,at2 ; at opt for byte elements
move.l d5,a2 ; pickup base address on mstack
move.l (a2),d7 ; base of object in d7
move.l -4(a3,d7.l),d0 ; d0 has ^class of object
clr.l d1
move.w 18(a3,d0.l),d1 ; d1 has dlen of object
add.l d1,d7 ; d7 points to idx hdr
move.l (SP),d0 ; get the index
lsl.w #1,d0 ; index * 2
add.l d0,d7 ; add the index
move.w 4(a3,d7.l),d1 ; fetch addr+4 (for idx hdr)
ext.l d1 ; sign extend
move.l d1,(sp)
gonext
*
dcode AT4,x,at2,at4 ; at opt for long elements
move.l d5,a2 ; pickup base address on mstack
move.l (a2),d7 ; base of object in d7
move.l -4(a3,d7.l),d0 ; d0 has ^class of object
clr.l d1
move.w 18(a3,d0.l),d1 ; d1 has dlen of object
add.l d1,d7 ; d7 points to idx hdr
move.l (SP),d0 ; get the index
lsl.w #2,d0 ; index * 4
add.l d0,d7 ; add the index
move.l 4(a3,d7.l),(SP) ; fetch addr+4 (for idx hdr)
gonext
*
dcode TO1,x,at4,to1 ; To opt for byte elements
move.l d5,a2 ; pickup base address on mstack
move.l (a2),d7 ; base of object in d7
move.l -4(a3,d7.l),d0 ; d0 has ^class of object
clr.l d1
move.w 18(a3,d0.l),d1 ; d1 has dlen of object
add.l d1,d7 ; d7 points to idx hdr
add.l (SP)+,d7 ; add the index
move.l (SP)+,d0
move.b d0,4(a3,d7.l) ; store to addr+4 (for idx hdr)
gonext
*
dcode TO2,x,to1,to2 ; To opt for byte elements
move.l d5,a2 ; pickup base address on mstack
move.l (a2),d7 ; base of object in d7
move.l -4(a3,d7.l),d0 ; d0 has ^class of object
clr.l d1
move.w 18(a3,d0.l),d1 ; d1 has dlen of object
add.l d1,d7 ; d7 points to idx hdr
move.l (SP)+,d0 ; get the index
lsl.w #1,d0 ; index * 2
add.l d0,d7 ; add the index
move.l (sp)+,d1
move.w d1,4(a3,d7.l) ; store to addr+4 (for idx hdr)
gonext
*
dcode TO4,x,to2,to4 ; to opt for long elements
move.l d5,a2 ; pickup base address on mstack
move.l (a2),d7 ; base of object in d7
move.l -4(a3,d7.l),d0 ; d0 has ^class of object
clr.l d1
move.w 18(a3,d0.l),d1 ; d1 has dlen of object
add.l d1,d7 ; d7 points to idx hdr
move.l (SP)+,d0 ; get the index
lsl.w #2,d0 ; index * 4
add.l d0,d7 ; add the index
move.l (SP)+,4(a3,d7.l) ; store to addr+4 (for idx hdr)
gonext
*
dcode ++4,x,to4,inc4 ; inc opt for long elements
move.l d5,a2 ; pickup base address on mstack
move.l (a2),d7 ; base of object in d7
move.l -4(a3,d7.l),d0 ; d0 has ^class of object
clr.l d1
move.w 18(a3,d0.l),d1 ; d1 has dlen of object
add.l d1,d7 ; d7 points to idx hdr
move.l (SP)+,d0 ; get the index
lsl.w #2,d0 ; index * 4
add.l d0,d7 ; add the index
move.l (SP)+,d1 ; get increment
add.l d1,4(a3,d7.l) ; inc addr+4 (for idx hdr)
gonext
*
dcode ++2,x,inc4,inc2 ; inc opt for word elements
move.l d5,a2 ; pickup base address on mstack
move.l (a2),d7 ; base of object in d7
move.l -4(a3,d7.l),d0 ; d0 has ^class of object
clr.l d1
move.w 18(a3,d0.l),d1 ; d1 has dlen of object
add.l d1,d7 ; d7 points to idx hdr
move.l (SP)+,d0 ; get the index
lsl.w #1,d0 ; index * 4
add.l d0,d7 ; add the index
move.l (SP)+,d1 ; get increment
add.w d1,4(a3,d7.l) ; inc addr+4 (for idx hdr)
gonext
*
dcode ++1,x,inc2,inc1 ; inc opt for byte elements
move.l d5,a2 ; pickup base address on mstack
move.l (a2),d7 ; base of object in d7
move.l -4(a3,d7.l),d0 ; d0 has ^class of object
clr.l d1
move.w 18(a3,d0.l),d1 ; d1 has dlen of object
add.l d1,d7 ; d7 points to idx hdr
move.l (SP)+,d0 ; get the index
add.l d0,d7 ; add the index
move.l (SP)+,d1 ; get increment
add.b d1,4(a3,d7.l) ; inc addr+4 (for idx hdr)
gonext
*
; fast left lshift ( val #shift -- val )
dcode <<,x,inc1,shfl
popd0
popd1
lsl.l d0,d1
move.l d1,-(SP)
gonext
*
; fast right lshift ( val #shift -- val )
dcode >>,x,shfl,shfr
popd0
popd1
lsr.l d0,d1
move.l d1,-(SP)
gonext
*
dcode (ABS),x,shfr,abs_ ; leave absolute of mstack addr
move.l d5,a2
move.l (a2),d0
add.l a3,d0
move.l d0,-(SP)
gonext
*
dcode COUNT,x,abs_,count
move.l (SP),d0
add.l #1,(SP)
clr.l d1
move.b 0(A3,d0.l),d1
move.l d1,-(SP)
gonext
*
dcode DEPTH,x,count,depth
move.l SP,d0
sub.l a3,d0
move.l #(s09-origin),d7
sub.l 0(a3,d7.l),d0
neg.l d0
asr.l #2,d0
pushD0
gonext
*
dcode FILL,x,depth,fil
popD0
fill1 popD1
move.l (SP)+,d7
l ,hld,pad,over,subt,semis
*
dcol HOLD,x,enum,hold
DATA pmone-origin
cfas hld1,hld,cstore,semis
*
dcol SIGN,x,hold,sign
cfas rot,zless
if. Z3
mlit $2d
cfas hold
then. Z3
cfas semis
*
dcol #,x,sign,sharp
cfas base,msmod,rot
mlit 9
cfas over,less
if. Z4
mlit 7
cfas plus
then. Z4
mlit $30
cfas plus,hold,semis
*
dcol #S,x,sharp,sharps
begin. Z5
cfas sharp,dup2,or_,zequ
until. Z5
cfas semis
*
dcol <#,x,sharps,snum
cfas pad,hld2,semis
*
dcol D.R,x,snum,ddotr
cfas toR,swap_,over,dabs,snum,sharps,sign,enum,rfrom
cfas over,subt,spaces,type,semis
*
dcol D.,x,ddotr,ddot
mlit 0
cfas ddotr,space,semis
*
dcol .,x,ddot,dot
cfas sToD,ddot,semis
*
dcol U.,x,dot,udot
mlit 0
cfas ddot,semis
*
dcol .R,x,udot,dotR
cfas toR,sToD,rfrom,ddotr,semis
*
dcol ?,x,dotR,quest
cfas fetch,dot,semis
*
dcol SPACE,x,quest,space
cfas bl,emit,semis
*
dcol SPACES,x,space,spaces
mlit 0
do. Z7
cfas bl,emit
loop. Z7
cfas semis
*
dcol -TRAILING,x,spaces,mtrail
cfas dup
mlit 0
do. Z8
cfas over,over,plus,min1,cfetch,bl,subt
eif. Z10
cfas leave
else. Z10
cfas min1
ethen. Z10
loop. Z8
cfas semis
*
dcol N>COUNT,x,mtrail,ncount
cfas count
mlit $1f
cfas and_,semis
*
dcol ID.,x,ncount,iddot
cfas ncount,type,space,semis
*
dcol EMIT,x,iddot,emit
cfas dup,emitvec,pemitv,pone ; send the char via Quickdraw
cfas out1,semis
*
dcol TYPE,x,emit,type
cfas dup,out1,dup2,typevec,ptypev,semis
dcol CR,x,type,cr
cfas crvec,pcrvec,semis
*
dcol CONTBOT,x,cr,contbot
cfas port_,lit,windowsize+origin,plus,plus4
cfas wfetch,semis
*
dcol CONTTOP,x,contbot,conttop
cfas port_,lit,windowsize+origin,plus
cfas wfetch,semis
*
dcol ?LEAD,x,conttop,qlead ; return proper leading for fo
cfas port_,lit,txsize+origin,plus,wfetch
cfas lit,120+origin,star,lit,50+origin,plus ; Increase 120 f
cfas lit,100+origin,slash,semis
*
dcol ?LINES,x,qlead,qlines ; number of even lines in port
cfas qlead,contbot,conttop ; bottom-top of content rgn
cfas subt,lit,5+origin,subt, ; less first line location
cfas over,plus1,subt ; minus ?LEAD+1
cfas swap_,slash,semis ; divided by ?LEAD
*
dcol BOTTOM,x,qlines,scrbot ; coordinate of screen bottom
cfas conttop,plus4,qlead,qlines,star,plus
cfas semis
*
dcol (CR),x,scrbot,cr_ ; simulate a CR in Quickdraw
cfas dotcur,fetxy,swap_,drop,lit,8+origin,swap_
cfas dup,scrbot,grt
eif. x27
cfas pzer,qlead,minus,scroll,gotoxy
else. x27
cfas qlead,plus
cfas gotoxy
ethen. x27
cfas dotcur,semis
*
dcol (BS),x,cr_,bs_
cfas dotcur,fetxy,swap_,lit,6+origin,subt,lit,8+origin,max
cfas swap_,dup2,gotoxy,curs_,pzer,curs_2
cfas bl,emit,curs_2,gotoxy,dotcur,semis
*
dcol ?TERMINAL,x,bs_,qterm
cfas lit,$28+origin,qevt,semis
*
dcol (KEY),x,qterm,key_
mlit $2A ; kbd and mouse events
cfas getevt,lit,2+origin,grt
eif. Z100
cfas ftemsg,lit,$00ff+origin,and_
else. Z100
cfas pmone
ethen. Z100
cfas semis
*
dcol (DKEY),x,key_,dkey_
cfas ufcb,pone,lit,ftwork ; read 1 char from disk
cfas read_,dup,dkerr2
eif. y10
cfas keystor,pone,curs_2 ; restore to terminal if err
cfas lit,13+origin
else. y10
cfas lit,ftwork,cfetch ; leav char on stack
ethen. y10
cfas qpause,semis
*
dcol KEY!,x,dkey_,keystor ; reset KEY to keyboard
cfas lit,key_,keyvec2,semis
*
dcol KEY,x,keystor,key
cfas keyvec,semis ; vectored key
*
dcol <",x,key,diskin ; set to disk key inpu
cfas ufcb,close_,dot ; close the oldfile
cfas lit,useFcb,lit,80+origin,era,pzer,curs_2
cfas lit,34+origin,word,here,dup,cfetch,plus1
cfas lit,useFname,swap_,cmove
cfas lit,useFname,basadr,lit,useFcb,sflptr
cfas ufcb,pone,open_,dot
cfas cr,lit,dkey_,keyvec2,semis
*
; ------------ Disk words for FORTH screen handling
dcol !FPTR,x,diskin,sflptr ; ( ^fname pblock -- )
cfas lit,18+origin,plus,store,semis
*
dcol ?COMP,x,sflptr,qcomp
cfas state,zequ,abq_
STR "compilation only "
cfas semis
*
dcol ?DP,x,qcomp,qdp ; dp grown into heap?
cfas room,pone,less,abq_
STR " out of room "
cfas semis
*
dcol ?STACK,x,qdp,qstack
cfas spfet,s0,swap_,uless
cfas abq_
STR "empty stack "
cfas semis
*
dcol ?EXEC,x,qstack,qexec
cfas state,cstate,or_,abq_ ; err if class or forth compile
STR "run state only "
cfas semis
*
dcol ?PAIRS,x,qexec,qpairs
cfas subt,abq_
STR "unpaired conditionals "
cfas semis
*
dcol ?CSP,x,qpairs,qcsp
cfas spfet,csp,subt,abq_
STR "definition not finished "
cfas semis
*
dcol (NUMBER),x,qcsp,num_
begin. Z27
cfas plus1,dup,tor,cfetch,base,digit
while. Z27
cfas swap_,base,ustar,drop,rot,base
cfas ustar,dplus,dpl,plus1
if. Z28
cfas pone,dpl1
then. Z28
cfas rfrom
repeat. Z27
cfas rfrom,semis
*
dcol ?NUM,x,num_,qnum ; ( addr -- d t OR f )
cfas pzer,pzer,rot,dup,plus1,cfetch
mlit $2d
cfas equals,dup,tor,plus,pmone
begin. Z30
cfas dpl2,num_,dup,cfetch,bl,subt
while. Z30
cfas dup,cfetch,lit,$2e+origin,subt
if. zz177
cfas rfrom,drop2,drop2,pzer,semis
then. zz177
cfas pzer
repeat. Z30
cfas drop,rfrom
if. Z31
cfas dminus
then. Z31
cfas pone,semis
*
dcol NUMBER,x,qnum,number ; ( addr -- d )
cfas qnum,zequ,abq_
STR "not found "
cfas semis
*
dcol LITERAL,I,number,liter
cfas state
if. Z32
cfas dup,lit
DATA $10000
cfas less,over,zless,zequ,and_
eif. zz39
cfas comp,wlit,wcomma
else. zz39
cfas comp,lit,comma ; builds word lit if n>=0 and n<$10000
ethen. zz39
then. Z32
cfas semis
*
dcol EXPECT,x,liter,expect
cfas over,plus,over
do. Z33
cfas key,dup,lit,8+origin,equals ; bs ?
eif. Z34
cfas drop,dup,i,equals,dup,rfrom,min2,plus,tor
eif. Z35
cfas lit,10+origin,beep
else. Z35
cfas bs_
ethen. Z35
cfas pzer
else. Z34
cfas dup,zequ
if. y118
cfas drop,lit,32+origin ; map null to space
then. y118
cfas dup,lit,$0d+origin,equals
eif. Z36
cfas leave,drop,pzer,pzer,cr
else. Z36
cfas dup
ethen. Z36
cfas r,cstore,pzer,r,plus1,cstore
ethen. Z34
cfas echovec
loop. Z33
cfas drop,semis
*
dcol WORD,x,expect,word
cfas tib
cfas in,plus,swap_,enclos
cfas word_,semis
*
dcol WORD",x,word,wordq ; lower-case version of word
cfas tib,in,plus,lit,34+origin,enclos
cfas lcword,here,semis
*
dcol FIND,x,wordq,mfind
cfas bl,word,ufind,dup,zequ
if. w72
cfas drop,here,contxt,fetch
cfas find_,dup,zequ
if. Z38
cfas contxt,currnt,subt
if. Z40
cfas drop,here,latest,find_
then. Z40
then. Z38
then. w72
cfas semis
*
ADJST ; X - null word
lkx DC.B $C1
DC.B $00
DATA lkmfind-origin
DATA colcode-origin ; not Fig standard -
cfas rfrom,drop ; note: doesn't support Forth screens
cfas semis
*
dcol "S,",x,x,scomma ; begin S, dict entry
cfas here,dup,cfetch,plus1,dup
cfas allot,pone,and_
if. sc10
cfas pzer,ccomma
then. sc10
cfas dup,rot,toggle,semis
*
dcol (CREATE),x,scomma,creat_
cfas here,pone,and_
if. Z430
cfas pzer,ccomma
then. Z430
cfas docs
if. Z410
cfas line_,wcomma
then. Z410
cfas mfind
if. Z420
cfas drop,nfa,iddot,dotq_
STR "is redefined "
cfas cr
then. Z420
cfas lit,$80+origin,scomma
cfas latest,comma,currnt
cfas store,here,plus4,comma,semis
*
dcol (INTRP),x,creat_,intrp_
begin. Z43
cfas mfind
eif. Z44
cfas state,less
eif. Z45
cfas cfa,comma
else. Z45
cfas cfa,exec
ethen. Z45
else. Z44
cfas here,number,dpl,plus1
eif. Z46
cfas dliter
else. Z46
cfas drop,liter
ethen. Z46
ethen. Z44
cfas qdp,qstack
again. Z43
cfas semis
*
dcol !CSP,x,intrp_,stcsp
cfas spfet,csp2,semis
*
dcol QUERY,x,stcsp,query
cfas tib,lit,$99+origin
cfas expvec,pzer,in2,semis
*
dcol <[,I,query,lbrak
mlit 0
cfas state2,semis
*
dcol ]>,x,lbrak,rbrak
mlit $c0
cfas state2,semis
*
dcol DEFINITIONS,x,rbrak,defs
cfas contxt,currnt2,semis
*
dcol <BUILDS,x,defs,builds
mlit 0
cfas const,semis
*
dcol OK,x,builds,ok
cfas depth,ptwo,dotr,base,dup
cfas lit,10+origin,equals
eif. xx11
cfas lit,45+origin,emit
else. xx11
cfas dup,lit,16+origin,equals
eif. xx12
cfas lit,36+origin,emit
else. xx12
cfas lit,63+origin,emit
ethen. xx12
ethen. xx11
cfas drop,lit,62+origin,emit
cfas semis
*
dcode Q,x,ok,q_
clr.w -(sp)
_hilitemenu
gonext
*
dcol QUIT,x,ok,quit
cfas pzer,in2
cfas lbrak,quvec,q_
cfas cr,ok
begin. Z48
cfas qdp,rpstor,query,interp,state,zequ
if. Z50
cfas ok
then. Z50
again. Z48
cfas semis
*
dcol BACK,x,quit,back
cfas here,subt,comma,semis
*
dcol FWD,x,back,fwd ; fill in fwd branch
cfas here,over,subt,swap_,store,semis
*
dcol BEGIN,I,fwd,begin
cfas qcomp,here,pone,semis
*
dcol THEN,I,begin,then
cfas qcomp,lit,2+origin,qpairs,fwd,semis
*
dcol DO,I,then,do ; compiles fwd branch for smart exit
cfas comp,do_,here,pzer,comma,lit,3+origin,semis
*
dcol LOOP,I,do,loop
cfas lit,3+origin,qpairs,comp,loop_,dup,plus4,back
cfas fwd,semis
*
dcol +LOOP,I,loop,ploop
cfas lit,3+origin,qpairs,comp,ploop_,dup,plus4,back
cfas fwd,semis
*
dcol COMPILE,x,ploop,comp
cfas qcomp,rfrom,dup,plus4
cfas tor,fetch,comma,semis
dcol [COMPILE],I,comp,bcomp
cfas fetpfa,cfa,comma,semis
*
dcol DLITERAL,I,bcomp,dliter
cfas state
if. Z51
cfas swap_,liter,liter
then. Z51
cfas semis
*
dcol UNTIL,I,dliter,until
cfas pone,qpairs,comp,bran0,back,semis
*
dcol AGAIN,I,until,again
cfas pone,qpairs,comp,bran,back,semis
*
dcol REPEAT,I,again,repeat
cfas tor,tor,again,rfrom,rfrom,min2
cfas then,semis
*
dcol IF,I,repeat,xif
cfas comp,bran0,here,pzer,comma,lit,2+origin,semis
*
dcol ELSE,I,xif,xelse
cfas lit,2+origin,qpairs,comp,bran,here,pzer,comma
cfas swap_,lit,2+origin,then,lit,2+origin,semis
*
dcol WHILE,I,xelse,while
cfas xif,plus2,semis
*
dcol EXIT,I,while,exit
cfas latest,pfa,cfa,fetch ; is this a pcolon def?
cfas lit,pcolcode,equals
eif. se10
cfas comp,semip ; yes, put in parm denester
else. se10
cfas comp,semis
ethen. se10
cfas semis
*
dcol ;,I,exit,semi ; immediate - semicolon def
cfas qcsp,exit,lbrak,semis
*
dcol .",I,semi,dotq
cfas state
eif. Z52
cfas comp,dotq_
cfas wordq ; lower-case word
cfas cfetch,plus1,aline,allot
else. Z52
cfas wordq,count,type
ethen. Z52
cfas semis
*
dcol IMMEDIATE,x,dotq,immed
cfas latest,lit,$40+origin,toggle,semis
*
dcol LATEST,x,immed,latest
cfas currnt,fetch,semis
*
dcol (,I,latest,lparen
cfas lit,$29+origin,word,semis
*
ADJST
lktick DC.B $c1 ; tick
DC.B $27
DATA lklparen-origin
tick DATA colcode-origin
cfas fetpfa,liter,semis
*
dcol FORGET,x,tick,forget
cfas defs ; set current to context
cfas tick,dup,fence,uless,abq_
STR "in protected dictionary "
cfas dup,nfa,dp2,lfa,fetch,currnt ; leave line# if sources on
cfas store,semis ; otherwise might forget nec stuff
*
dcol ROOM,x,forget,room ; leave dict space left
cfas msiz,fetch,dp,bdp,fetch
cfas subt,subt,semis
*
dcol GREET,x,room,greet
cfas cls
mlit hello-origin
cfas count,type,cr
mlit bytesleft-origin
cfas count,type
cfas room,dot,cr,semis
*
dcol COLD,x,greet,xcold
cfas lit,aregn,fetch,zequ
if. w59
cfas intool ; only if we haven't gotten heap already
then. w59
cfas lit,inits0,fetch,s02,lit,initr0,fetch,r02
cfas lit,initfenc,fetch,fence2,lit,initvocl,fetch,vocl2
cfas lit,initdp,fetch,dp2,lit,initmp,fetch,m02
cfas lit,initlast,fetch,lit,forth_
cfas lit,$0a+origin,plus,store,decim,spstor,mpstor \ careful on the 0a
cfas forth_,defs,pzer,warn2,objini,greet,quit,semis
*
dcol .PAUSE,x,xcold,dpause
cfas lit,pausemsg,count,type,semis
*
dcol ?PAUSE,x,dpause,qpause ; check if user wants to stop
cfas qterm
if. w43
cfas key_,drop,cr,dpause
cfas key_,cr,lit,0+origin,out2,lit,32+origin,grt
if. w44
cfas abort
then. w44
then. w43
cfas semis
*
dcol ABORT,x,qpause,abort
cfas cr
cfas spstor,mpstor,lit,key_,keyvec2,decim
cfas pone,curs_2,qstack,lbrak,forth_
cfas defs,abvec
cfas lit,$a850+origin,trap_ ; initCursor
cfas quit,semis
*
ddoes YERK,x,abort,forth_,dovocab ; FORTH vocabulary
DC.W $8120
vlf DATA lastdef-origin
DATA 0
*
dcol .VAL,x,forth_,dotval
cfas dotr,lit,2+origin,spaces,semis
*
dcol ?CFA,x,dotval,qcfa
cfas dup,plus4,nfa,ncount
cfas tor,r,plus,plus4,aline
cfas over,equals,rfrom,land_,semis
*
dcol (.STACK),x,qcfa,dstak_
cfas base,lit,ftwork1,store,dup2,grt ; preserve current base
eif. z61
do. z62
cfas cr,ifetch,dup,decim
cfas lit,8+origin,dotval,dup,hex,lit,36+origin,emit
cfas pzer,lit,6+origin,ddotr
cfas lit,3+origin,spaces,aline,min4,plus1,false
eif. z63
cfas plus4,nfa,iddot
else. z63
cfas drop
ethen. z63
cfas pfour
ploop. z62
else. z61
cfas lit,emptymsg,count,type,less
cfas abq_
STR "Stack Underflow "
ethen. z61
cfas lit,ftwork1,fetch,base2,cr restore base
cfas semis
*
Lastdef dcol .S,x,dstak_,dots
cfas spfet,s0,swap_,lit,dsmsg
cfas count,type,dstak_,r0,rpfet,lit,rsmsg
cfas count,type,dstak_,m0,mpfet,lit,msmsg
cfas count,type,dstak_
cfas semis
*
nextdef EQU *
ENDR
*
SEG 0,32,VAR.LEN,$20
SEG0
SEG_1 JP start,1
JP getInstL,1
END_1
SEG_2 JP origin,2
JP coldvec,2
JP getDict,2
END_2
END0
ENDR
*
* END
RSRC YERK,0,32
STR "Yerk Version 3.6.7"
ENDR
*
RSRC FREF,128,32
ASC 'APPL'
DATA /0
STR ""
ENDR
*
RSRC FREF,129,32
ASC 'COM '
DATA /1
STR ""
ENDR
*
RSRC FREF,130,32
ASC 'USER'
DATA /2
STR ""
ENDR
*
RSRC FREF,131,32
ASC 'BIN '
DATA /3
STR ""
ENDR
*
RSRC FREF,132,32
ASC 'TEXT'
DATA /4
STR ""
ENDR
*
RSRC ICN#,128,32
HEX 71c0.0000.cb20.0000
HEX c620.0000.6040.0000
HEX 3080.0000.1900.1f80
HEX 1900.2040.197e.4020
HEX 1981.9810.1e8e.e408
HEX 0ccf.3f87.3069.1803
HEX c864.8003.c864.4003
HEX c8c8.f003.c99f.8ff3
HEX c981.990f.c9ff.9903
HEX c8fd.8200.c801.8400
HEX c801.8200.c801.91ce
HEX c801.9939.c801.9f32
HEX c801.d724.c800.e308
HEX c800.0304.cfff.e322
HEX c000.1331.c000.1339
HEX ffff.e3ef.7fff.c1c6
*
HEX 71c0.0000.fbe0.0000
HEX ffe0.0000.7fc0.0000
HEX 3f80.0000.1f00.1f80
HEX 1f00.3fc0.1f7e.7fe0
HEX 1fff.fff0.1ffe.e7f8
HEX 0fff.ffff.3ff9.ffff
HEX fffc.ffff.fffc.7fff
HEX fff8.ffff.ffff.ffff
HEX ffff.ff0f.ffff.ff03
HEX ffff.fe00.ffff.fc00
HEX ffff.fe00.ffff.ffce
HEX ffff.ffff.ffff.fffe
HEX ffff.fffc.ffff.fff8
HEX ffff.fffc.ffff.fffe
HEX ffff.ffff.ffff.c1ff
HEX ffff.c1ef.7fff.c1c6
ENDR
*
RSRC ICN#,129,32
HEX 71c7.fffe.cb2c.0001
HEX c62c.0001.604f.fff9
HEX 3087.fff9.1900.0019
HEX 1900.0019.197e.0019
HEX 1981.0019.1e8e.0019
HEX 0ccc.0019.3068.0019
HEX c864.0019.c864.0019
HEX c8c8.fc19.c99f.8219
HEX c981.9919.c9ff.9919
HEX c8fd.821f.c801.840e
HEX c801.8200.c801.91ce
HEX c801.9939.c801.9f32
HEX c801.d724.c800.e308
HEX c800.0304.cfff.e322
HEX c000.1331.c000.1339
HEX ffff.e3ef.7fff.c1c6
*
HEX 71c7.fffe.fbef.ffff
HEX ffef.ffff.7fcf.ffff
HEX 3fff.ffff.1fff.ffff
HEX 1fff.ffff.1fff.ffff
HEX 1fff.ffff.1fff.ffff
HEX 0fff.ffff.3fff.ffff
HEX ffff.ffff.ffff.ffff
HEX ffff.ffff.ffff.ffff
HEX ffff.ffff.ffff.ffff
HEX ffff.ffff.ffff.ffff
HEX ffff.fff8.ffff.ffff
HEX ffff.ffff.ffff.ffff
HEX ffff.fffe.ffff.fffc
HEX ffff.fffc.ffff.fffe
HEX ffff.f3ff.ffff.f3ff
HEX ffff.e3ef.7fff.c1c6
ENDR
*
RSRC ICN#,130,32
HEX 71c7.fffe.cb2c.0001
HEX c62c.0001.604f.fff9
HEX 3087.fff9.1900.0019
HEX 1900.0019.1900.0019
HEX 1900.0019.1e00.0019
HEX 0c00.0019.3000.0019
HEX c800.0019.c800.0019
HEX c800.0019.c800.0019
HEX c800.0019.c800.0019
HEX c800.001f.c800.000f
HEX c800.0000.c800.01ce
HEX c800.0339.c800.0332
HEX c800.0324.c800.0308
HEX c800.0304.cfff.e322
HEX c000.1331.c000.1339
HEX ffff.e3cf.7fff.c1c6
*
HEX 71c7.fffe.fbef.ffff
HEX ffef.ffff.7fff.ffff
HEX 3fff.ffff.1fff.ffff
HEX 1fff.ffff.1fff.ffff
HEX 1fff.ffff.1fff.ffff
HEX 0fff.ffff.3fff.ffff
HEX 7fff.ffff.ffff.ffff
HEX ffff.ffff.ffff.ffff
HEX ffff.ffff.ffff.ffff
HEX ffff.ffff.ffff.ffff
HEX ffff.fffe.ffff.ffff
HEX ffff.ffff.ffff.ffff
HEX ffff.fffe.ffff.fffc
HEX ffff.fffc.ffff.fffe
HEX ffff.ffff.ffff.f3ff
HEX ffff.e3ef.7fff.c1c6
ENDR
*
RSRC ICN#,131,32
HEX 71c7.fffe.cb2c.0001
HEX c62c.0001.604f.fff9
HEX 3087.fff9.1900.0019
HEX 1900.0019.1900.0019
HEX 1909.1899.1e09.2499
HEX 0c09.2499.0009.1899
HEX 7000.0019.c800.0019
HEX c989.2319.ca49.2499
HEX ca49.2499.c989.2319
HEX c800.001f.c800.000f
HEX c988.c000.ca49.21ce
HEX ca49.2339.c988.c332
HEX c800.0324.c800.0308
HEX c800.0304.cfff.f322
HEX c000.0b31.c000.0b39
HEX ffff.f3cf.7fff.e1c6
*
HEX 71c7.fffe.fbef.ffff
HEX ffef.ffff.7fff.ffff
HEX 3fff.ffff.1fff.ffff
HEX 1fff.ffff.1fff.ffff
HEX 1fff.ffff.1fff.ffff
HEX 0fff.ffff.0fff.ffff
HEX 7fff.ffff.ffff.ffff
HEX ffff.ffff.ffff.ffff
HEX ffff.ffff.ffff.ffff
HEX ffff.ffff.ffff.ffff
HEX ffff.fffe.ffff.ffff
HEX ffff.ffff.ffff.ffff
HEX ffff.fffe.ffff.fffc
HEX ffff.fffc.ffff.fffe
HEX ffff.ffff.ffff.ffff
HEX ffff.f7ff.7fff.e7ce
ENDR
*
RSRC ICN#,132,32
HEX 71